Migrate the Site Creation Domain Search to wordpress-rs - #23247

Typing the first character hides the intro block and swaps the search icon
for a spinner. `animateLayoutChanges` animated the resulting bounds change,
which is what makes the screen jump and the keyboard flicker while the first
results load.

The views around the header now snap rather than animating. #23247 drops the
attribute from the site creation search, where the same animation was taking
focus off the search field.

Typing the first character hides the intro block and swaps the search icon
for a spinner. `animateLayoutChanges` animated the resulting bounds change,
which is what makes the screen jump and the keyboard flicker while the first
results load.

The views around the header now snap rather than animating. #23247 drops the
attribute from the site creation search, where the same animation was taking
focus off the search field.

* Migrate `DomainSuggestionsViewModel` from FluxC to wordpress-rs

Fetch domain products and suggestions through `WpComApiClient` instead of
`ProductsStore` and the `Dispatcher`/EventBus pair. Suspend calls remove the
need for the `@Subscribe` handler and the dispatcher registration.

Changes:
- Swap `ProductsStore` and `Dispatcher` for `WpComApiClientProvider` and
  `AccountStore`
- Map the `empty_results` rejection to an empty success, as FluxC's
  `SiteRestClient.suggestDomains` did
- Carry the API's message into `ListState.Error`, and log failures with
  `toLogErrorString`
- Retarget `Product.isOnSale` at the wordpress-rs `Product`, whose `saleCost`
  holds hundredths of the currency unit rather than a decimal amount
- Extract `buildSuggestionsParams`, and cover the sale, error and superseded
  query paths

* Cover the product type the suggestions screen requests

Extract `buildProductsParams` so the filter can be asserted. `request` takes
an opaque lambda, so a verify on the client counts calls without pinning
which endpoint each one reached: swapping `ProductTypeFilter.Domains` for
another filter left every test green while no suggestion would carry a sale
price.

Changes:
- Extract `buildProductsParams` and assert it selects `Domains`
- Rename `domain products are fetched only at first start` to name the
  repeat-start guarantee its call count actually covers

* Bind each test observer to the list it was created with

The observers closed over the `onDomainSelectedEvents` and `suggestionStates`
fields, which `createViewModel` reassigns. A test that builds a second view
model leaves the first one's observers writing into the second one's lists.

* Name the non-API failure test after what it asserts

The fallback to `R.string.domain_suggestions_fetch_error` happens in
`DomainSuggestionsFragment`, which this test does not exercise. It asserts
that `ListState.Error` carries no message.

* Handle the suggestions response on the main thread

`suggestions` is a plain field written from the search field, the debouncer
and the response handler. FluxC pinned the handler to the main thread through
`@Subscribe(threadMode = ThreadMode.MAIN)`; the coroutine that replaced it
runs on `BG_THREAD`, so a response landing while `fetchSuggestions` is still
running can be overwritten by the stale state that thread holds. `postValue`
then coalesces the two, leaving the spinner up with no error reported.

A request that fails without reaching the network, as it does with no
connection, is fast enough to make the overlap likely.

Changes:
- Inject the `UI_THREAD` dispatcher and run `onDomainSuggestionsFetched` on it

* Tell the user when a domain search failed for want of a connection

The screen reported every failure as "Domain suggestions couldn't be loaded",
including the one the user can act on. wordpress-rs distinguishes a request
that never reached the network, so an offline search now says to check the
connection.

Changes:
- Set `errorMessageResId` to `error_network_connection` when the result is a
  `DeviceIsOfflineError`
- Prefer `errorMessageResId` over `errorMessage` in the fragment's toast

* Drop the implicit layout animation from the domain search

Typing the first character hides the intro block and swaps the search icon
for a spinner. `animateLayoutChanges` animated the resulting bounds change,
which is what makes the screen jump and the keyboard flicker while the first
results load.

The views around the header now snap rather than animating. #23247 drops the
attribute from the site creation search, where the same animation was taking
focus off the search field.

* Report a failed domain search once

A failed search with nothing already on screen showed two messages at once:
the empty view said no domains were found while a toast said the suggestions
could not be loaded. The empty view is attached to the list through
`setEmptyView`, so it appears for any empty list including the one an error
leaves behind.

The failure now goes into the empty view when the list is empty, with the
reason as its subtitle, and falls back to a toast only when there are still
results on screen to keep.

* Start the domain search at rest rather than loading

The layout shipped the search icon `gone` and the progress bar visible, the
inverse of the `tools:visibility` on each. The fragment corrects both the
first time `suggestions` is assigned, so any path that reaches the screen
without issuing a search leaves the spinner running with nothing behind it.

* Clear the suggestions when a search fails

The list answers the query in the search field, and `ListState.Error` is
built from the previous state's data. Rejecting a query therefore left the
previous query's results on screen beneath the new text, so searching `...`
after a real search showed that search's domains as though they answered it.

The results are already hidden while a request is in flight, so this stops a
failure restoring them rather than introducing a new behaviour. With the list
always empty on failure, the empty view carries every error and the toast goes
away, which also stops the longer API messages being truncated.

* Clear the search results when the field is emptied

Emptying the field left the last result on screen, so an error explaining how
a query has to be written stayed up after that query was deleted. Clearing
now returns the list to `Init`, the state the screen opens in, and the
fragment hides the list and its empty view there as it does while loading.

The default search that follows an emptied field is unchanged, so the site's
own suggestions still come back when they were not already showing.

* Stop searching for a blank query

A site with no name gives `initializeDefaultSuggestions` nothing to search
for, on open and again whenever the field is emptied. The blank query went to
the API, which rejects it as `invalid_query`, so emptying the field replaced
the error it was meant to clear with an identical one.

A blank query now leaves the list in `Init` without a request, which is the
resting state the field's placeholder already implies.

* Keep the suggestions through a configuration change

Restoring the view state sets the search field's text, and `TextView` reports
that as a change even when the text is empty, so a rotation tells the view
model the query was cleared. Clearing reset the list to `Init`, and no fetch
follows when the query is already the site name, so the retained suggestions
were replaced by a blank screen with no way back but typing.

Emptying the field now only resets the list when the query has moved off the
site name, which is the case the reset exists for.

* Clear the selected domain when no search is issued

`fetchSuggestions` clears the selection at the end, and the blank-query guard
returns before reaching it. Emptying the field on a site with no name left
the Select button enabled over a list that had just been cleared, holding a
domain the user could no longer see, and tapping it created a cart.

The reset also moves above the request, so every write this thread makes to
`suggestions` is done before a response can arrive on another one. The
comment on the response handler claimed that as an effect of running on the
main thread, which it never was — `fetchSuggestions` runs on the debouncer's
scheduler, so the two threads overlapped either way.

* Drop part of a comment in DomainSuggestionsViewModel that referred an earlier implementation

* Report a missing WP.com account rather than assuming one

`AccountStore.accessToken` is typed nullable but reads `""` when signed out,
and is only null between an in-process sign out and the next launch. A null
check therefore passed in the case it was written for and the screen sent
`Authorization: Bearer ` for the server to reject, which arrived as the same
generic failure as a dropped connection. In the case it did catch it threw
inside `launch`, where nothing handles it.

`getOrCreateClient` now returns null for either shape, matching
`FetchAllDomainsUseCase`, and both requests report it instead: the product
fetch logs and carries on, and the search shows the error the fragment
already has a string for.

* Write the suggestions state from one thread

`suggestions` was read-modify-written from three threads: the debouncer's
scheduler in `fetchSuggestions`, the main thread from the row taps and the
response handler, and `BG_THREAD` from `showLoadingButton` during cart
creation. Tapping Select as a response landed could interleave two of those
cycles, dropping the fetched list or leaving rows enabled mid-purchase.

`fetchSuggestions` and `showLoadingButton` now run on the main thread with
the rest. The query is still read on the debouncer thread and passed in, so
it remains the one the search was scheduled for rather than whatever the
field holds by the time the main thread gets there.

`getOrCreateClient` treats a null and an empty `accessToken` alike, which reads
as a redundant check without knowing that `AccountStore` uses the two to mean
the same thing. Documents it, matching #23247 and #23255.